package model

import (
	"fmt"
	"yunwei/go_api/application/database"
)

// 用常量定义了任务状态
// 0-正常 -1-错误 -2-超时
const (
	TASK_SUCESS  = 0
	TASK_ERROR   = -1
	TSAK_TIMEOUT = -2
)

// 任务
type Task struct {
	Id            int
	GroupId       int
	ServerId      int
	TaskName      string
	Description   string
	CronSpec      string
	Concurrent    int
	Command       string
	Timeout       int
	ExecuteTimes  int
	PrevTime      int64
	IsNotify      int
	NotifyType    int
	NotifyUserIds string
	Status        int
	CreateTime    int64
	CreateId      int
	UpdateTime    int64
	UpdateId      int
}

func (task *Task) TableName() string {
	return "cron_task"
}

// 变更任务状态
func (task *Task) Update(fields ...string) error {
	err := database.Orm.Model(task).Select(fields).Updates(task).Error
	if err != nil {
		return err
	}
	return nil
}

// 获取任务列表
func TaskGetList(page, pageSize int, filters ...interface{}) ([]*Task, int64) {
	var tasks []*Task
	var total int64
	query := database.Orm.Model(&Task{})
	if len(filters) > 0 {
		// 使用循环设置多个条件
		for i := 0; i < len(filters); i += 2 {
			field := filters[i].(string)
			value := filters[i+1]
			query = query.Where(fmt.Sprintf("%s=?", field), value)
		}
	}
	query.Count(&total)
	query.Limit(pageSize).Offset((page - 1) * pageSize).Order("id desc").Find(&tasks)
	return tasks, total
}

// 依据id获取任务
func TaskGetById(id int) (*Task, error) {
	task := &Task{}
	err := database.Orm.First(task, id).Error
	if err != nil {
		return nil, err
	}
	return task, nil
}

// 任务分组
type Group struct {
	Id          int
	GroupName   string
	Description string
	CreateId    int
	CreateTime  int64
	UpdateId    int
	UpdateTime  int64
	// 1-正常 0-删除
	Status int
}

func (group *Group) TableName() string {
	return "cron_task_group"
}
func GroupGetList(page, pageSize int, filters ...interface{}) ([]*Group, int64) {

	var groups []*Group
	var total int64

	query := database.Orm.Model(&Group{})
	if len(filters) > 0 {
		// 使用循环设置多个条件
		for i := 0; i < len(filters); i += 2 {
			field := filters[i].(string)
			value := filters[i+1]
			query = query.Where(field, value)
		}
	}
	query.Count(&total)
	query.Offset((page - 1) * pageSize).Limit(pageSize).Order("id DESC").Find(&groups)
	return groups, total
}

func (group *Group) Update(fields ...string) error {
	err := database.Orm.Model(group).Select(fields).Updates(group).Error
	if err != nil {
		return err
	}
	return nil
}
func TaskGroupGetById(id int) (*Group, error) {

	group := &Group{}
	err := database.Orm.First(group, id).Error
	if err != nil {
		return nil, err
	}
	return group, nil
}

type TaskLog struct {
	Id     int
	TaskId int
	Output string
	Error  string
	// 0-正常 -1-错误 -2-超时
	Status int
	// 任务耗时
	ProcessTime int
	CreateTime  int64
}

func (tasklog *TaskLog) TableName() string {
	return "cron_task_log"
}

// 添加任务记录
func TaskLogAdd(t *TaskLog) error {
	database.Orm.Create(t)
	return nil
}

// 依据任务记录列表
func TaskLogGetList(page, pageSize int, filters ...interface{}) ([]*TaskLog, int64) {
	var total int64
	query := database.Orm.Table("cron_task_log")
	if len(filters) > 0 {
		l := len(filters)
		for k := 0; k < l; k += 2 {
			query = query.Where(filters[k].(string)+" = ?", filters[k+1])
		}
	}
	query.Count(&total)
	var list []*TaskLog
	err := query.Order("id DESC").Limit(pageSize).Offset((page - 1) * pageSize).Find(&list).Error
	if err != nil {
		fmt.Println(err)
	}
	return list, total
}

// 依据id获取任务记录
func TaskLogGetById(id int) (*TaskLog, error) {
	taskLog := &TaskLog{}
	err := database.Orm.First(taskLog, id).Error
	if err != nil {
		return nil, err
	}
	return taskLog, nil
}

// 依据id删除任务记录
func TaskLogDelById(id int) error {
	database.Orm.Model(&TaskLog{}).Delete(id)
	return nil
}
